#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>

#define CHRDEVBASE_MAJOR 200 /* 主设备号 */
#define CHRDEVBASE_NAME "chrdevbase" /* 设备名 */

// static char readbuf[100]; /* 读缓冲区 */
// static char writebuf[100]; /* 写缓冲区 */
// static char kerneldata[] = {"kernel data!"};

#define DEVICE_BUFFER_SIZE 100

static char device_buffer[DEVICE_BUFFER_SIZE]; /* 用于保存用户写入的数据 */
static int buffer_len = 0; /* 记录当前数据长度 */


static int chrdevbase_open(struct inode *inode, struct file *filp)
{
//printk("chrdevbase open!\r\n");
    return 0;
}

/*
* @description : 从设备读取数据
* @param - filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param - offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t chrdevbase_read(struct file *filp, 
                                char __user *buf,
                                size_t cnt, 
                                loff_t *offt)
{
   int retvalue = 0;

    printk("chrdevbase read! Requested: %zu bytes\n", cnt);

    // 如果用户请求的长度大于实际数据，只返回实际长度
    if (cnt > buffer_len) {
        cnt = buffer_len;
    }

    // 将保存的数据发送给用户空间
    retvalue = copy_to_user(buf, device_buffer, cnt);
    if (retvalue == 0) {
        printk(KERN_INFO "内核发送数据成功: %.*s\n", (int)cnt, device_buffer);
    } else {
        printk(KERN_ERR "内核发送数据失败!\n");
    }

    return cnt; // 返回实际读取的字节数
}

/*
* @description : 向设备写数据
* @param - filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param - offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t chrdevbase_write(struct file *filp,
                                const char __user *buf,
                                size_t cnt, loff_t *offt)
{
 int retvalue = 0;

    printk("chrdevbase write! Received: %zu bytes\n", cnt);

    // 限制写入长度，防止溢出
    if (cnt >= DEVICE_BUFFER_SIZE) {
        cnt = DEVICE_BUFFER_SIZE - 1; // 留一个字节给 '\0'
    }

    // 从用户空间复制数据到内核缓冲区
    retvalue = copy_from_user(device_buffer, buf, cnt);
    if (retvalue == 0) {
        device_buffer[cnt] = '\0'; // 手动添加字符串结束符（可选）
        buffer_len = cnt; // 更新长度
        printk(KERN_INFO "kernel received: %s\n", device_buffer);
    } else {
        printk(KERN_ERR "kernel receive failed!\n");
        return -EFAULT;
    }

    return cnt; // 返回实际写入的字节数
}

/*
* @description : 关闭/释放设备
* @param - filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
 static int chrdevbase_release(struct inode *inode,
                                struct file *filp)
{
    //printk("chrdevbase release！\r\n");
    return 0;
}

/*
* 设备操作函数结构体
*/
static struct file_operations chrdevbase_fops = {
                                                .owner = THIS_MODULE, 
                                                .open = chrdevbase_open,
                                                .read = chrdevbase_read,
                                                .write = chrdevbase_write,
                                                .release = chrdevbase_release,
};
/*
* @description : 驱动入口函数
* @param : 无
* @return : 0 成功;其他 失败
*/
static int __init chrdevbase_init(void)
{
    int retvalue = 0;

    /* 注册字符设备驱动 */
    retvalue = register_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME,&chrdevbase_fops);
    if(retvalue < 0){
    printk(KERN_INFO "chrdevbase driver register failed\r\n");
    }
    printk(KERN_INFO "chrdevbase_init()\r\n");
    return 0;
}
/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit chrdevbase_exit(void)
{
    /* 注销字符设备驱动 */
    unregister_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME);
    printk(KERN_INFO "chrdevbase_exit()\r\n");
}

/* 
* 将上面两个函数指定为驱动的入口和出口函数
*/
module_init(chrdevbase_init);
module_exit(chrdevbase_exit);

/* 
* LICENSE 和作者信息
*/
MODULE_LICENSE("GPL");
MODULE_AUTHOR("JACK");
MODULE_INFO(intree, "Y");


